{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# cnn-mnist\n",
    "使用tensorflow，构造并训练一个神经网络，在测试机上达到超过98%的准确率。 \n",
    "作业详情：https://gitee.com/ai100/quiz-w7-1-cnn-mnist "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'channels_last'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"A very simple MNIST classifier.\n",
    "See extensive documentation at\n",
    "https://www.tensorflow.org/get_started/mnist/beginners\n",
    "\"\"\"\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import argparse\n",
    "import sys\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "from keras.layers.core import Dense, Flatten, Dropout\n",
    "from keras.layers.convolutional import Conv2D\n",
    "from keras.layers.pooling import MaxPooling2D\n",
    "from keras import initializers\n",
    "from keras.layers import advanced_activations\n",
    "\n",
    "from keras import backend as K\n",
    "\n",
    "K.image_data_format() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在这里调用系统提供的Mnist数据函数为我们读入数据，如果没有下载的话则进行下载。\n",
    "\n",
    "<font color=#ff0000>**这里将data_dir改为适合你的运行环境的目录**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-698ada706af1>:3: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\t10k-images-idx3-ubyte.gz\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n"
     ]
    }
   ],
   "source": [
    "# Import data\n",
    "data_dir = '/tmp/tensorflow/mnist/input_data'\n",
    "mnist = input_data.read_data_sets(data_dir, one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义输入输出\n",
    "x = tf.placeholder(tf.float32, [None, 784])\n",
    "y_ = tf.placeholder(tf.float32, [None, 10])\n",
    "# 学习速率\n",
    "learning_rate = tf.placeholder(tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('reshape'):\n",
    "  x_image = tf.reshape(x, [-1, 28, 28, 1])\n",
    "\n",
    "\n",
    "# 二维卷积层，即对图像的空域卷积。\n",
    "# keras.layers.convolutional.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, \n",
    "#                                  dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer='glorot_uniform', \n",
    "#                                  bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, \n",
    "#                                  activity_regularizer=None, kernel_constraint=None, bias_constraint=None)\n",
    "# filters：卷积核的数目（即输出的维度）\n",
    "# kernel_size：卷积核的宽度和长度。如为单个整数，则表示在各个空间维度的相同长度。\n",
    "# strides：卷积的步长。如为单个整数，则表示在各个空间维度的相同步长。\n",
    "# activation：激活函数，如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）\n",
    "# padding：补0策略，为“valid”, “same” 。\n",
    "# use_bias:布尔值，是否使用偏置项\n",
    "# kernel_initializer：权值初始化方法\n",
    "# bias_initializer：权值初始化方法\n",
    "# kernel_regularizer：施加在权重上的正则项\n",
    "# bias_regularizer：施加在偏置向量上的正则项\n",
    "# activity_regularizer：施加在输出上的正则项\n",
    "# kernel_constraints：施加在权重上的约束项\n",
    "# bias_constraints：施加在偏置上的约束项\n",
    "\n",
    "# 卷积层1\n",
    "net = Conv2D(32, kernel_size=[7,7], strides=[1,1], activation='selu', padding='same',\n",
    "             kernel_initializer = 'glorot_normal',  # Glorot正态分布初始化方法，也称作Xavier正态分布初始化\n",
    "             bias_initializer = initializers.Constant(value=0.01), \n",
    "             input_shape=[28,28,1])(x_image)  \n",
    "# 第一层卷积必须显示指定input_shape输入数据形状[高，宽，通道数]\n",
    "# Conv2D 是类方法，第一层时需传递输入数据x_image\n",
    "\n",
    "\n",
    "# 最大值池化层\n",
    "# keras.layers.pooling.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)\n",
    "# pool_size：代表在两个方向（竖直，水平）上的下采样因子，如取（2，2）将使图片在两个维度上均变为原长的一半。\n",
    "# strides：步长值\n",
    "# border_mode：‘valid’或者‘same’\n",
    "# data_format：“channels_first”或“channels_last”之一，代表图像的通道维的位置。以128x128的RGB图像为例，\n",
    "#              “channels_first”应将数据组织为（3,128,128），而“channels_last”应将数据组织为（128,128,3）。\n",
    "\n",
    "# 池化层1\n",
    "net = MaxPooling2D(pool_size=[2,2])(net) # 池化\n",
    "\n",
    "#卷积层2\n",
    "net = Conv2D(64, kernel_size=[5,5], strides=[1,1],activation='selu', padding='same', \n",
    "             kernel_initializer = 'glorot_normal',  # Glorot正态分布初始化方法，也称作Xavier正态分布初始化\n",
    "             bias_initializer = initializers.Constant(value=0.01))(net)\n",
    "\n",
    "# 池化层2\n",
    "net = MaxPooling2D(pool_size=[2,2])(net)\n",
    "\n",
    "# Flatten层，用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。Flatten不影响batch的大小。\n",
    "net = Flatten()(net) \n",
    "\n",
    "# Dropout层\n",
    "net = Dropout(0.7)(net)\n",
    "\n",
    "# 全连接层\n",
    "# keras.layers.core.Dense(units, activation=None, use_bias=True, kernel_initializer='glorot_uniform', \n",
    "#                         bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, \n",
    "#                         activity_regularizer=None, kernel_constraint=None, bias_constraint=None)\n",
    "# units：大于0的整数，代表该层的输出维度\n",
    "# activation：激活函数，如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）\n",
    "# use_bias: 布尔值，是否使用偏置项\n",
    "# kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器\n",
    "# bias_initializer：偏置向量初始化方法，为预定义初始化方法名的字符串，或用于初始化偏置向量的初始化器\n",
    "# kernel_regularizer：施加在权重上的正则项\n",
    "# bias_regularizer：施加在偏置向量上的正则项\n",
    "# activity_regularizer：施加在输出上的正则项\n",
    "# kernel_constraints：施加在权重上的约束项\n",
    "# bias_constraints：施加在偏置上的约束项\n",
    "\n",
    "# 全连接层1\n",
    "net = Dense(1000, activation='selu')(net) # 全连接层\n",
    "\n",
    "# 全连接层2\n",
    "net = Dense(10,activation='softmax')(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算交叉熵\n",
    "from keras.objectives import categorical_crossentropy\n",
    "cross_entropy = tf.reduce_mean(categorical_crossentropy(y_, net)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2_loss = tf.add_n( [tf.nn.l2_loss(w) for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)] )\n",
    "#惩罚因子，即正则化因子\n",
    "regularization_rate = 1e-4\n",
    "total_loss = cross_entropy + regularization_rate * l2_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(total_loss)\n",
    "sess = tf.Session()\n",
    "K.set_session(sess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 100, entropy loss: 0.205445, l2_loss: 793.370972, total loss: 0.284782, lr: 0.100000, accuracy: 0.970000\n",
      "step 200, entropy loss: 0.205377, l2_loss: 793.628296, total loss: 0.284739, lr: 0.100000, accuracy: 0.990000\n",
      "step 300, entropy loss: 0.117309, l2_loss: 793.303162, total loss: 0.196639, lr: 0.100000, accuracy: 1.000000\n",
      "step 400, entropy loss: 0.046759, l2_loss: 792.864136, total loss: 0.126045, lr: 0.100000, accuracy: 1.000000\n",
      "step 500, entropy loss: 0.032730, l2_loss: 792.146667, total loss: 0.111944, lr: 0.100000, accuracy: 1.000000\n",
      "step 500, 训练正确率:  0.977255\n",
      "step 500, 测试正确率:  0.978000\n",
      "step 600, entropy loss: 0.036822, l2_loss: 791.663635, total loss: 0.115989, lr: 0.100000, accuracy: 1.000000\n",
      "step 700, entropy loss: 0.017058, l2_loss: 791.053650, total loss: 0.096163, lr: 0.100000, accuracy: 1.000000\n",
      "step 800, entropy loss: 0.077416, l2_loss: 790.093567, total loss: 0.156425, lr: 0.100000, accuracy: 1.000000\n",
      "step 900, entropy loss: 0.073666, l2_loss: 789.228821, total loss: 0.152589, lr: 0.100000, accuracy: 0.990000\n",
      "step 1000, entropy loss: 0.044005, l2_loss: 788.275330, total loss: 0.122832, lr: 0.100000, accuracy: 1.000000\n",
      "step 1000, 训练正确率:  0.985473\n",
      "step 1000, 测试正确率:  0.983000\n",
      "step 1100, entropy loss: 0.021920, l2_loss: 787.411682, total loss: 0.100661, lr: 0.100000, accuracy: 1.000000\n",
      "step 1200, entropy loss: 0.074187, l2_loss: 786.406738, total loss: 0.152828, lr: 0.100000, accuracy: 1.000000\n",
      "step 1300, entropy loss: 0.060748, l2_loss: 785.485168, total loss: 0.139297, lr: 0.100000, accuracy: 1.000000\n",
      "step 1400, entropy loss: 0.016233, l2_loss: 784.492188, total loss: 0.094682, lr: 0.100000, accuracy: 1.000000\n",
      "step 1500, entropy loss: 0.008643, l2_loss: 783.485596, total loss: 0.086991, lr: 0.100000, accuracy: 1.000000\n",
      "step 1500, 训练正确率:  0.987509\n",
      "step 1500, 测试正确率:  0.984900\n",
      "step 1600, entropy loss: 0.103358, l2_loss: 782.497925, total loss: 0.181608, lr: 0.100000, accuracy: 1.000000\n",
      "step 1700, entropy loss: 0.064208, l2_loss: 781.592102, total loss: 0.142367, lr: 0.100000, accuracy: 0.990000\n",
      "step 1800, entropy loss: 0.031270, l2_loss: 780.614868, total loss: 0.109332, lr: 0.100000, accuracy: 1.000000\n",
      "step 1900, entropy loss: 0.049222, l2_loss: 779.468262, total loss: 0.127169, lr: 0.100000, accuracy: 1.000000\n",
      "step 2000, entropy loss: 0.008246, l2_loss: 778.399841, total loss: 0.086086, lr: 0.100000, accuracy: 1.000000\n",
      "step 2000, 训练正确率:  0.990964\n",
      "step 2000, 测试正确率:  0.987900\n",
      "step 2100, entropy loss: 0.005904, l2_loss: 777.420959, total loss: 0.083647, lr: 0.100000, accuracy: 1.000000\n",
      "step 2200, entropy loss: 0.029067, l2_loss: 776.389404, total loss: 0.106706, lr: 0.100000, accuracy: 1.000000\n",
      "step 2300, entropy loss: 0.068071, l2_loss: 775.355225, total loss: 0.145607, lr: 0.100000, accuracy: 1.000000\n",
      "step 2400, entropy loss: 0.073665, l2_loss: 774.147949, total loss: 0.151080, lr: 0.100000, accuracy: 1.000000\n",
      "step 2500, entropy loss: 0.008202, l2_loss: 772.951111, total loss: 0.085497, lr: 0.100000, accuracy: 1.000000\n",
      "step 2500, 训练正确率:  0.992673\n",
      "step 2500, 测试正确率:  0.987900\n",
      "step 2600, entropy loss: 0.012895, l2_loss: 772.002869, total loss: 0.090096, lr: 0.100000, accuracy: 1.000000\n",
      "step 2700, entropy loss: 0.046565, l2_loss: 770.957397, total loss: 0.123661, lr: 0.100000, accuracy: 0.990000\n",
      "step 2800, entropy loss: 0.005559, l2_loss: 769.973083, total loss: 0.082557, lr: 0.100000, accuracy: 1.000000\n",
      "step 2900, entropy loss: 0.001609, l2_loss: 768.900879, total loss: 0.078499, lr: 0.100000, accuracy: 1.000000\n",
      "step 3000, entropy loss: 0.004370, l2_loss: 767.807190, total loss: 0.081150, lr: 0.100000, accuracy: 1.000000\n",
      "step 3000, 训练正确率:  0.990618\n",
      "step 3000, 测试正确率:  0.986100\n",
      "step 3100, entropy loss: 0.008483, l2_loss: 766.678162, total loss: 0.085151, lr: 0.100000, accuracy: 1.000000\n",
      "step 3200, entropy loss: 0.023968, l2_loss: 765.676697, total loss: 0.100536, lr: 0.100000, accuracy: 1.000000\n",
      "step 3300, entropy loss: 0.001086, l2_loss: 764.594299, total loss: 0.077546, lr: 0.100000, accuracy: 1.000000\n",
      "step 3400, entropy loss: 0.007074, l2_loss: 763.553894, total loss: 0.083430, lr: 0.100000, accuracy: 1.000000\n",
      "step 3500, entropy loss: 0.008070, l2_loss: 762.496582, total loss: 0.084319, lr: 0.100000, accuracy: 1.000000\n",
      "step 3500, 训练正确率:  0.993800\n",
      "step 3500, 测试正确率:  0.989500\n",
      "step 3600, entropy loss: 0.011809, l2_loss: 761.364990, total loss: 0.087946, lr: 0.100000, accuracy: 1.000000\n",
      "step 3700, entropy loss: 0.005346, l2_loss: 760.338379, total loss: 0.081380, lr: 0.100000, accuracy: 1.000000\n",
      "step 3800, entropy loss: 0.015898, l2_loss: 759.250793, total loss: 0.091823, lr: 0.100000, accuracy: 1.000000\n",
      "step 3900, entropy loss: 0.057233, l2_loss: 758.128967, total loss: 0.133046, lr: 0.100000, accuracy: 1.000000\n",
      "step 4000, entropy loss: 0.004410, l2_loss: 756.989624, total loss: 0.080109, lr: 0.100000, accuracy: 1.000000\n",
      "step 4000, 训练正确率:  0.995327\n",
      "step 4000, 测试正确率:  0.989100\n",
      "step 4100, entropy loss: 0.003981, l2_loss: 755.910767, total loss: 0.079573, lr: 0.100000, accuracy: 1.000000\n",
      "step 4200, entropy loss: 0.024414, l2_loss: 754.757507, total loss: 0.099889, lr: 0.100000, accuracy: 1.000000\n",
      "step 4300, entropy loss: 0.011389, l2_loss: 753.580017, total loss: 0.086747, lr: 0.100000, accuracy: 1.000000\n",
      "step 4400, entropy loss: 0.009532, l2_loss: 752.415771, total loss: 0.084773, lr: 0.100000, accuracy: 1.000000\n",
      "step 4500, entropy loss: 0.010889, l2_loss: 751.232117, total loss: 0.086012, lr: 0.100000, accuracy: 1.000000\n",
      "step 4500, 训练正确率:  0.997036\n",
      "step 4500, 测试正确率:  0.990500\n",
      "step 4600, entropy loss: 0.003987, l2_loss: 750.103333, total loss: 0.078998, lr: 0.100000, accuracy: 1.000000\n",
      "step 4700, entropy loss: 0.000997, l2_loss: 748.915222, total loss: 0.075888, lr: 0.100000, accuracy: 1.000000\n",
      "step 4800, entropy loss: 0.002429, l2_loss: 747.823792, total loss: 0.077211, lr: 0.100000, accuracy: 1.000000\n",
      "step 4900, entropy loss: 0.002952, l2_loss: 746.696533, total loss: 0.077622, lr: 0.100000, accuracy: 1.000000\n",
      "step 5000, entropy loss: 0.003505, l2_loss: 745.583374, total loss: 0.078063, lr: 0.087000, accuracy: 1.000000\n",
      "step 5000, 训练正确率:  0.996945\n",
      "step 5000, 测试正确率:  0.989400\n",
      "step 5100, entropy loss: 0.028953, l2_loss: 744.545837, total loss: 0.103408, lr: 0.087000, accuracy: 1.000000\n",
      "step 5200, entropy loss: 0.009440, l2_loss: 743.490112, total loss: 0.083789, lr: 0.087000, accuracy: 1.000000\n",
      "step 5300, entropy loss: 0.003814, l2_loss: 742.462952, total loss: 0.078060, lr: 0.087000, accuracy: 1.000000\n",
      "step 5400, entropy loss: 0.006550, l2_loss: 741.409607, total loss: 0.080691, lr: 0.087000, accuracy: 1.000000\n",
      "step 5500, entropy loss: 0.003049, l2_loss: 740.362183, total loss: 0.077085, lr: 0.075690, accuracy: 1.000000\n",
      "step 5500, 训练正确率:  0.999036\n",
      "step 5500, 测试正确率:  0.991400\n",
      "step 5600, entropy loss: 0.002937, l2_loss: 739.422668, total loss: 0.076879, lr: 0.075690, accuracy: 1.000000\n",
      "step 5700, entropy loss: 0.002430, l2_loss: 738.495056, total loss: 0.076279, lr: 0.075690, accuracy: 1.000000\n",
      "step 5800, entropy loss: 0.001527, l2_loss: 737.576477, total loss: 0.075285, lr: 0.075690, accuracy: 1.000000\n",
      "step 5900, entropy loss: 0.003493, l2_loss: 736.642700, total loss: 0.077158, lr: 0.075690, accuracy: 1.000000\n",
      "step 6000, entropy loss: 0.005051, l2_loss: 735.713074, total loss: 0.078622, lr: 0.065850, accuracy: 1.000000\n",
      "step 6000, 训练正确率:  0.998818\n",
      "step 6000, 测试正确率:  0.991200\n",
      "step 6100, entropy loss: 0.001095, l2_loss: 734.888367, total loss: 0.074584, lr: 0.065850, accuracy: 1.000000\n",
      "step 6200, entropy loss: 0.003123, l2_loss: 734.046326, total loss: 0.076528, lr: 0.065850, accuracy: 1.000000\n",
      "step 6300, entropy loss: 0.006353, l2_loss: 733.217590, total loss: 0.079675, lr: 0.065850, accuracy: 1.000000\n",
      "step 6400, entropy loss: 0.001340, l2_loss: 732.403076, total loss: 0.074580, lr: 0.065850, accuracy: 1.000000\n",
      "step 6500, entropy loss: 0.004675, l2_loss: 731.563904, total loss: 0.077832, lr: 0.057290, accuracy: 1.000000\n",
      "step 6500, 训练正确率:  0.999436\n",
      "step 6500, 测试正确率:  0.990600\n",
      "step 6600, entropy loss: 0.000815, l2_loss: 730.841370, total loss: 0.073899, lr: 0.057290, accuracy: 1.000000\n",
      "step 6700, entropy loss: 0.001445, l2_loss: 730.120850, total loss: 0.074457, lr: 0.057290, accuracy: 1.000000\n",
      "step 6800, entropy loss: 0.001238, l2_loss: 729.386353, total loss: 0.074176, lr: 0.057290, accuracy: 1.000000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 6900, entropy loss: 0.005948, l2_loss: 728.667664, total loss: 0.078815, lr: 0.057290, accuracy: 1.000000\n",
      "step 7000, entropy loss: 0.002455, l2_loss: 727.946533, total loss: 0.075250, lr: 0.049842, accuracy: 1.000000\n",
      "step 7000, 训练正确率:  0.999436\n",
      "step 7000, 测试正确率:  0.990900\n",
      "step 7100, entropy loss: 0.000247, l2_loss: 727.321655, total loss: 0.072979, lr: 0.049842, accuracy: 1.000000\n",
      "step 7200, entropy loss: 0.005383, l2_loss: 726.693726, total loss: 0.078052, lr: 0.049842, accuracy: 1.000000\n",
      "step 7300, entropy loss: 0.000213, l2_loss: 726.063904, total loss: 0.072819, lr: 0.049842, accuracy: 1.000000\n",
      "step 7400, entropy loss: 0.001625, l2_loss: 725.444397, total loss: 0.074170, lr: 0.049842, accuracy: 1.000000\n",
      "step 7500, entropy loss: 0.001538, l2_loss: 724.799561, total loss: 0.074018, lr: 0.043363, accuracy: 1.000000\n",
      "step 7500, 训练正确率:  0.999782\n",
      "step 7500, 测试正确率:  0.992100\n"
     ]
    }
   ],
   "source": [
    "init_op = tf.global_variables_initializer()\n",
    "sess.run(init_op)\n",
    "batch_size = 100\n",
    "# 学习速率\n",
    "lr = 0.10\n",
    "# 学习速率的衰减率\n",
    "lr_decay = 0.87\n",
    "acc_train_mat = []\n",
    "acc_test_mat = []\n",
    "loss_mat = []\n",
    "l2_loss_mat = []\n",
    "total_loss_mat = []\n",
    "# 训练\n",
    "for step in range(10000):   \n",
    "    # 当训练集loss出现波动或趋于平稳，开始学习速率衰减\n",
    "    if (step+1) >= 5000 and (step+1) % 500 == 0:\n",
    "        # 衰减学习速率\n",
    "        lr *= lr_decay\n",
    "        \n",
    "    batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n",
    "    _, loss, l2_loss_value, total_loss_value = sess.run(\n",
    "               [train_step, cross_entropy, l2_loss, total_loss], \n",
    "               feed_dict={x: batch_xs, y_: batch_ys, learning_rate:lr})\n",
    "    if (step+1) % 100 == 0: \n",
    "        # 测试模型\n",
    "        correct_prediction = tf.equal(tf.argmax(net, 1), tf.argmax(y_, 1))\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "        print('step %d, entropy loss: %f, l2_loss: %f, total loss: %f, lr: %f, accuracy: %f' % \n",
    "                (step+1, loss, l2_loss_value, total_loss_value, lr, sess.run(accuracy, feed_dict={x: batch_xs, y_: batch_ys})))\n",
    "        loss_mat.append(loss)\n",
    "        l2_loss_mat.append(l2_loss_value)\n",
    "        total_loss_mat.append(total_loss_value)\n",
    "        \n",
    "        if (step+1) % 500 == 0:\n",
    "            batch_size_pre = 1000\n",
    "            # 计算训练误差，因显卡内存不足，故分批计算求平均值\n",
    "            train_size = mnist.train.images.shape\n",
    "            acc_batch = 0\n",
    "            acc = []\n",
    "            step_time = (int)(train_size[0]/batch_size_pre)\n",
    "            for step_train in range(step_time):\n",
    "                batch_xs, batch_ys = mnist.train.next_batch(batch_size_pre)\n",
    "                acc_batch = sess.run(accuracy, feed_dict={x: batch_xs, y_: batch_ys})\n",
    "                acc.append(acc_batch)\n",
    "            step_acc_train = np.mean(acc)\n",
    "            print('step %d, 训练正确率:  %f' % (step+1, step_acc_train))\n",
    "            acc_train_mat.append(step_acc_train)\n",
    "\n",
    "            # 计算测试误差，因显卡内存不足，故分批计算求平均值\n",
    "            test_size = mnist.test.images.shape\n",
    "            acc_batch = 0\n",
    "            acc = []\n",
    "            step_time = (int)(test_size[0]/batch_size_pre)\n",
    "            for step_test in range(step_time):\n",
    "                batch_xs_test, batch_ys_test = mnist.test.next_batch(batch_size_pre)\n",
    "                acc_batch = sess.run(accuracy, feed_dict={x: batch_xs_test, y_: batch_ys_test})\n",
    "                acc.append(acc_batch)\n",
    "            step_acc_test = np.mean(acc)\n",
    "            print('step %d, 测试正确率:  %f' % (step+1, step_acc_test))\n",
    "            acc_test_mat.append(step_acc_test)\n",
    "            \n",
    "            if step_acc_test >= 0.9917:\n",
    "                break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#可视化\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.plot(range(len(loss_mat)), loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_entropy_loss')\n",
    "plt.show() \n",
    "\n",
    "plt.plot(range(len(l2_loss_mat)), l2_loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_l2_loss')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(range(len(total_loss_mat)), total_loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_total_loss')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(range(len(acc_train_mat)), acc_train_mat, label='Train Accuracy') \n",
    "plt.plot(range(len(acc_test_mat)), acc_test_mat, label='Test Accuracy')\n",
    "plt.legend()\n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('accuracy')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "毫无疑问，这个模型是一个非常简陋，性能也不理想的模型。目前只能达到92%左右的准确率。\n",
    "接下来，希望大家利用现有的知识，将这个模型优化至98%以上的准确率。\n",
    "Hint：\n",
    "- 卷积\n",
    "- 池化\n",
    "- 激活函数\n",
    "- 正则化\n",
    "- 初始化\n",
    "- 摸索一下各个超参数\n",
    "  - 卷积kernel size\n",
    "  - 卷积kernel 数量\n",
    "  - 学习率\n",
    "  - 正则化惩罚因子\n",
    "  - 最好每隔几个step就对loss、accuracy等等进行一次输出，这样才能有根据地进行调整"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
